\documentclass[final]{beamer}
%\usepackage{htwbeamer}

%\usetheme{Berkeley}

%\usepackage{inconsolata}

\usepackage[ngerman]{babel}
\usepackage[utf8]{inputenc}
\usetheme{Antibes}
\usecolortheme{dolphin}

\usefonttheme{professionalfonts}

\useinnertheme{default}
%\useoutertheme{tree}
\useoutertheme{infolines}

\setbeamercovered{transparent}


\graphicspath{{./pics/}}

\title[Python Krypto]{Präsentation zum Projekt Sicherheit und Kryptographie}
\author{S. Theobald -- H.P. Bui}
\institute{HTW}
%\date{14. 03. 2011}
\definecolor{titleColor}{RGB}{0,102,204}

\begin{document}
\begin{frame}
	%\titlepage
	\begin{center}
		{\small 
			HTW des Saarlandes -- Fakultät für Ingenieurwissenschaften \\
			Projekt Sicherheit und Kryptographie
		}
	\end{center}
	\vfill
	\begin{center}
		
		\textcolor{titleColor}
		{
			{\LARGE Präsentation zum \\
				''Projekt Kryptographie'' 
				\vspace{0.6em}\\ }
		}

		\vspace{0.5cm}
		14. 03. 2012 \\
		\vspace{0.5cm}
		{\large\rmfamily Sarah \textsc{Theobald} \hspace{1cm} Hong Phuc \textsc{Bui}}

	\end{center}
\end{frame}

\begin{frame}{Inhaltsverzeichnis}
	\tableofcontents
\end{frame}
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%


\section{Übersicht}
\begin{frame}{Übersicht}
	\begin{itemize}
		\item \texttt{base64, base32, base16}
		\item Groestl -- a SHA 3 -- Candidate
		\item Diffie-Hellman Schlüsselaustausch
		\item Pollard-$\lambda$
		\item SSL Zertifikate
	\end{itemize}
\end{frame}


\section{Implementierung von \texttt{baseX}, X = 64, 32, 16}

\begin{frame}{Schwierigkeiten}
\begin{itemize}
	\item Python Syntax
\end{itemize}
\end{frame}


\begin{frame}{Wozu wird die Base Verschlüsselung gebraucht?}
	\begin{itemize}
		\item Binäre Daten in ASCII umzuwandeln
		\item Plattform-unabhängiges Datenaustauschformat
	\end{itemize}
\end{frame}



\begin{frame}{Vorgehensweise bei der Implementierung}
\begin{itemize}
\item gemeinsames Lesen der Spezifikation (RFC 4648)
\item jedes Team Mitglied programmierte für sich selbst \\ $\rightarrow$ 2 unterschiedliche Versionen
	\begin{itemize}
	\item Verarbeitung auf Bitebene (Zerlegung in Blöcke)
	\item Verarbeitung auf Stringebene (Konvertierung in 0 und 1)
	\end{itemize}
\end{itemize}
\end{frame}


\begin{frame}{Lernerfolg}
\begin{itemize}
\item die ersten Codezeilen in Python
\item Erlernen einfacher Verschlüsselungen
\end{itemize}
\end{frame}



%\begin{frame}{Zweck}
%	\begin{itemize}
%		\item Binäre Daten in ASCII umzuwandern
%		\item Plattformunabhängiges Datenaustauschformat
%	\end{itemize}
%\end{frame}
%\begin{frame}{Spezifikation}
%	\begin{itemize}
%		\item \texttt{baseX} werden in RFC 4648 spezifiziert.
%		\item \texttt{base64}: aus 3-Byte Block wird in 4 6-Bit Block umgewandelt.
%		\item \texttt{base32}: aus 5-Byte Block wird in 8 5-Bit Block umgewandelt.
%		\item \texttt{base32}: aus 1-Byte Block wird in 2 4-Bit Block umgewandelt.
%		\item Padding-Charakter : \texttt{=}
%	\end{itemize}
%\end{frame}

%\begin{frame}{Implementation}
%	\begin{itemize}
%		\item Zwei Verfahren:
%			\begin{itemize}
%				\item String-Operation
%				\item Bit-Ebene-Operation
%			\end{itemize}
%		\item Zwei Programmierungsstile
%			\begin{itemize}
%				\item Objekt-orientierte Stile
%				\item Prozedurale Stile
%			\end{itemize}
%	\end{itemize}
%\end{frame}


\section{Groestl - a SHA 3 - Candidate}


\begin{frame}{Schwierigkeiten}
\begin{itemize}
\item Spezifikation: Padding 
\item Umsetzung 
\end{itemize}
\end{frame}

\begin{frame}{Vorgehensweise bei der Implementierung}
\begin{itemize}
\item Entscheiden zwischen prozeduraler und Objekt-orientierter Programmierung
\item Objekt-orientiert: Kapselung der Operationen und Daten in eine Einheit
\item Aufteilung in zwei Dateien: \texttt{matrix.py} und \texttt{hash.py}
\item \texttt{matrix.py}: Aufbau der Matrix und Entwickeln der vorgegeben Methoden
\item \texttt{hash.py}: Implementieren der Operationen die Matrix betreffend
\item Besonderheit: Funktion \texttt{groestHash}: Schnittelle der API
\end{itemize}
\end{frame}

\begin{frame}{Lernerfolg}
\begin{itemize}
\item schwierige Sachverhalte erkennen und in Quellcode umsetzen
\item theoretische Themengebiete (Matrizen) praktisch umsetzen
\item im Nachhinein: schwierigste Aufgabenstellung
\end{itemize}
\end{frame}


\section{Diffie-Hellman Schlüsselaustausch}

\begin{frame}{Schwierigkeiten}
	\begin{itemize}
		\item klare Abgrenzung zwischen Schlüsselaustausch und den Nachrichten
		\item Verhalten bei Fehler im Schlüsselaustausch
		\item Verhalten bei Fehler im Nachrichtenaustausch
		\item Bestätigung, ob Nachricht erhalten wurde
		\item Wie kann umgesetzt werden, dass die Kommunikationspartner gleichberechtigt 					sind?
	\end{itemize}
\end{frame}

\begin{frame}{Lösungsansätze}
	\begin{itemize}
		\item Abgrenzung erfolgt mit Hilfe von JSON
		\item Fehler bei Austausch: Kommunikationspartner beenden sich ordnungsgemäß
		\item Bestätigung (Confirm) gesendet, ob Nachricht erhalten wurde
		\item Client - Server Modell. Keine Gleichberechtigung
	\end{itemize}
\end{frame}


\begin{frame}{Vorgehensweise beim Implementieren}
	\begin{itemize}
		\item Festlegen der Technologien (die nicht vorgegeben wurden)
		\item ''Implementieren'' des Schlüssel- und Nachrichtenaustausches auf dem Papier
		\item Grundgerüst des Client - Server Modells schreiben
		\item Umsetzen der ''anlogen'' Implementierung in Quellcode
	\end{itemize}
\end{frame}

\begin{frame}{verwendete Technologien}
	\begin{enumerate}
	\item JSON: JavaScript Object Notation
		\begin{itemize}
			\item einfacherer Datenaustausch über Netzwerk
			\item Vorteile von JSON: 
				\begin{itemize}
					\item Daten in menschenlesbarer Form
					\item Programmiersprachen unabhängig
					\item einfach zu parsen			
					\item Beispiel: \\
						\texttt{\{"Name":"Bob"\}}
				\end{itemize}
		\end{itemize}
	\item PARI/GP
		\begin{itemize}
			\item gewöhnungsbedürftige Syntax
			\item sehr effizientes Programm im Umgang mit Primzahlen \\
			$\rightarrow$ Erzeugen des Schlüssels
		\end{itemize}
	\end{enumerate}
\end{frame}


\begin{frame}[fragile]{Protokoll}
\textbf{Theorie:}

	\begin{tabular}{cccc}
                 &  Alice           &                   & Bob            \\
                 & $a^r \mod p$     & $\longrightarrow$ &                \\
                 &                  & $\longleftarrow$  & $a^s \mod p$      \\
Gemeinsamer Key: & $(a^s)^r \mod p$ &                   & $(a^r)^s \mod p$  \\
	\end{tabular}

\vspace{1cm}
\textbf{Praxis:}\\
{\footnotesize
\begin{verbatim}
Alice                                                              Bob
---> {"Handshake1": 
      24335516419366764669736212796959875787371700376028288588146}
     {"Handshake2": 
      62393559305561210870852674478929457966103727139386736117433} <---
---> {"Message": "43bfa688a0e4aeff"}
     {"Confirm": "ef5f91ece7dc2a0d"}                               <---
\end{verbatim}
}
\end{frame}

\begin{frame}{Lernerfolg}
\begin{itemize}
\item Verknüpfung von Teilgebieten des BA - Studiums mit neuen Inhalten 
\item bessere Zusammenarbeit und lockerere Atmosphäre
\end{itemize}
\end{frame}


\section{Pollard--$\lambda$--Reihe}
\begin{frame}{Schwierigkeiten}
	\begin{itemize}
		\item wie kann man realisieren, dass mehrere Clients bedient werden können?
		\item Vorgehen bei Fehlverhalten des Servers oder einem der Clients
		\item wie teilt der Server mit, dass er eine Kollision gefunden hat?
	\end{itemize}
\end{frame}

\begin{frame}{Probleme}
	\begin{itemize}
		\item fertige Implementierung konnte nur einen Client handeln \\
		$\rightarrow$ komplettes Überarbeiten und Umschreiben auf asynchrone Kommunikation 
	\end{itemize}
\end{frame}

\begin{frame}{Lösungsansätze}
\begin{itemize}
		\item Server besteht aus zwei Teilen: 
			\begin{description}
				\item [\texttt{Server}] Empfängt den Kontakt vom Client, leitet diesen 								weiter an einen 
				 \texttt{DLHandler}, und wartet auf den nächsten Client
				\item [\texttt{DLHandler}] verarbeitet Daten des Clients. Bei gefundener 							Kollision berechnet er das Ergebnis.
			\end{description}
		 \item Client: 
			 \begin{itemize}
				 \item Empfängt das DL-Problem vom Server.
				 \item Berechnet distinguish Point mit zufälligen Startwerten und sendet 							   diesen an Server.
			 \end{itemize}
		\item Server sendet an Client eine Bestätigung bei gefundener Kollision \\
				$\rightarrow$ Server beendet sich \\
				$\rightarrow$ Kommunikationskanal wird auf Serverseite geschlossen \\
				$\rightarrow$ Clients beenden sich
\end{itemize}	
\end{frame}	
	
	
\begin{frame}{Implementierung}
	\begin{itemize}
		\item Anwendung der Bibliothek \texttt{asyncore}
			um asynchrone Kommunikation zu realisieren.
	\end{itemize}
\end{frame}

\begin{frame}{Lernerfolg}
	\begin{itemize}
		\item Implementieren einer asynchronen Kommunikation 
		\item Umsetzen der, in der Vorlesung ''Sicherheit und Kryptographie'' erlernten Theorie
	\end{itemize}
\end{frame}



\section{SSL - Zertifikate}
\begin{frame}{Schwierigkeiten}
	\begin{itemize}
		\item wie kommt man effizient an die Zertifikate?
		\item wie findet man möglichst viele Server?
		\end{itemize}
\end{frame}

\begin{frame}{Lösungsansatz}
	\begin{enumerate}
		\item Programm nmap
			\begin{itemize}
				\item zu langsam beim Scannen des Ports 443
				\item gefundener Server: Port nicht offen
			\end{itemize}
		\item Google und wget
			\begin{itemize}
				\item Output in Javascript $\rightarrow$ schwierig zu Parsen
			\end{itemize}
		\item Ixquick und wget
			\begin{itemize}
				\item Vorteil: Output in html $\rightarrow$ Parsen deutlich einfacher
				\item Nachteil: verwendet Post-Methode, um Anfrage zu senden
			\end{itemize}
		\item Bsp: eine POST-Option in Ixquick \\
				\url{"cmd=process_search&language=english&\
		 			qid=MHLNMSLSNSMK&rcount=&\
		 			rl=NONE&query=https&cat=web&engine0=v1all&startat="}
	\end{enumerate}
\end{frame}


\begin{frame}{Implementierung}
Drei Schritte:
\begin{itemize}
	\item Konvertierung von pem-Format (X509/base64) nach text-Format
		(M2Crypto-Bibliothek) RFC 2459
	\item Parsen der Zertifikate in Text-Format (die Klasse Certificate)
	\item Ausgabe in CSV-Datei speichern
\end{itemize}
\end{frame}


\begin{frame}{Auswertung}
	\begin{itemize}
		\item Anzahl der untersuchten Server: 319
		\item Anzahl der Server, die RSA verwenden: 319
		\item Anzahl der Server mit Schluessellange 1024 : 130
		\item Anzahl der Server mit Schluessellange 4096 : 8
		\item Anzahl der Server mit Schluessellange 2048 : 181
		\item Anzahl der Server mit Exponenten 65537 : 314
		\item Anzahl der Server mit Exponenten 17 : 5	
	\end{itemize}
\end{frame}


\begin{frame}{Lernerfolg}
	\begin{itemize}
		\item Erstellen eigener SSL Zertifikate
		\item richtige Informationen aus einer Datei auslesen und diese verarbeiten 
	\end{itemize}
\end{frame}

\section{Fazit}
\begin{frame}{Fazit}
	\begin{itemize}
		\item gute Wissensvermittlung an Hand von interessanten Aufgabenstellungen
		\item gute Vorlesung, um das Thema Kryptographie zu vertiefen
		\item zeit intensivste Vorlesung in diesem Semester 
	\end{itemize}
\end{frame}


\section*{Fragen?}
\begin{frame}
	\begin{center}
		\huge{Vielen Dank für die Aufmerksamkeit.}
	\end{center}
\end{frame}

\end{document}
